package com.yueman.ptoolopenticket.ticket.Tpl.Lixin;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Validator;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.yueman.ptoolopenticket.ticket.Tpl.CommonFileTemplate;
import com.yueman.ptoolopenticket.ticket.Tpl.CommonTemplate;
import com.yueman.ptoolopenticket.ticket.Tpl.CommonTicketTemplate;
import com.yueman.ptoolopenticket.ticket.config.LixinConfig;
import com.yueman.ptoolopenticket.ticket.dto.ResponseResult;
import com.yueman.ptoolopenticket.ticket.dto.Result;
import com.yueman.ptoolopenticket.ticket.dto.ResultBuilder;
import com.yueman.ptoolopenticket.ticket.dto.request.lixin.*;
import com.yueman.ptoolopenticket.ticket.dto.response.lixin.*;
import com.yueman.ptoolopenticket.ticket.mapper.TicketSignRepository;
import com.yueman.ptoolopenticket.ticket.mapper.TicketTraceRepository;
import com.yueman.ptoolopenticket.ticket.mapper.TicketUserRepository;
import com.yueman.ptoolopenticket.ticket.pojo.Sign;
import com.yueman.ptoolopenticket.ticket.pojo.Trace;
import com.yueman.ptoolopenticket.ticket.pojo.User;
import com.yueman.ptoolopenticket.ticket.utils.Constant;
import com.yueman.ptoolopenticket.ticket.utils.lixin.BaseImg;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

@Component(Constant.LIXIN)
@Slf4j
public class LixinTpl implements CommonTemplate, CommonTicketTemplate, CommonFileTemplate {
    @Autowired
    LixinConfig lixinConfig;
    @Autowired
    TicketSignRepository ticketSignRepository;

    @Autowired
    TicketUserRepository userRepository;
    @Autowired
    TicketTraceRepository traceRepository;

    /**
     * 注册
     *
     * @param userReq
     * @return
     */
    @Override
    public Result<UserRes> register(UserReq userReq) {
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.zc");
        map.put("userId", "");
        map.put("shen", userReq.getProvince());
        map.put("shi", userReq.getCity());
        map.put("qx", userReq.getDistrict());
        map.put("sfzjhm", userReq.getIdno());
        map.put("sjhm", userReq.getPhone());
        map.put("sjyzm", userReq.getVerificationcode());
        map.put("yqm", userReq.getInvitationcode());
        map.put("xm", userReq.getName());
        log.info("register:{}", JSONUtil.toJsonPrettyStr(map));
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("returnCode"), "00")) {
            UserRes userRes = new UserRes();
            userRes.setCode(Constant.SUCCESS_CODE);
            userRes.setRetMsg(retmap.get("returnMessage"));
            userRes.setUserid(retmap.get("userId"));
            User user = new User();
            user.setDistrict(map.get("qx").toString());
            user.setIdno(map.get("sfzjhm").toString());
            user.setUid(map.get("sjhm").toString());
            user.setPhone(map.get("sjhm").toString());
            user.setInvitationcode(map.get("yqm").toString());
            user.setUid(retmap.get("userId"));
            userRepository.save(user);
            return ResultBuilder.success(userRes);
        }
        return ResultBuilder.fail(retmap.get("returnMessage"));
    }

    /**
     * 获取手机验证码
     *
     * @param verificationReq
     * @return
     */
    @Override
    public Result<VerificationRes> VerificationCode(VerificationReq verificationReq) {
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.getZcYzm");
        map.put("userId", "");
        map.put("sjhm", verificationReq.getPhone());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (!Validator.isMobile(verificationReq.getPhone())) {
            return ResultBuilder.fail(ResponseResult.NOTPHONE);
        }
        if (retmap.get("returnCode").equals("00")) {
            VerificationRes verificationRes = new VerificationRes();
            verificationRes.setRetCode(Constant.SUCCESS_CODE);
            verificationRes.setRetMsg(retmap.get("returnMessage"));
            return ResultBuilder.success(verificationRes);
        }
        return ResultBuilder.fail(retmap.get("returnMessage"));
    }

    /**
     * 签约
     *
     * @param signReq
     * @return
     */
    @Override
    public Result<SignRes> sign(SignReq signReq) {
        User user = userRepository.findUserByUid(signReq.getUid());
        if (user == null) {

            return ResultBuilder.fail(ResponseResult.REPEATFAILSIGN);
        }
        Map<String, Object> map = new HashMap<>();
        String data = signReq.getValiddate();
        String mmyy = data.substring(5) + data.substring(3, 5);
        map.put("ywlx", "sqypt.dkfpsq.agreeapply");
        map.put("userId", user.getUid());
        map.put("sssf", signReq.getArea());
        map.put("accttype", signReq.getAcctType());
        map.put("acctno", signReq.getAcctNo());
        map.put("idno", signReq.getIdNo());
        map.put("acctname", signReq.getAcctName());
        map.put("mobile", signReq.getPhone());
        map.put("cvv2", signReq.getCvv2());
        map.put("validdate", mmyy);
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("retcode"), "00")) {
            Map<String, Object> thpinfo = JSONUtil.toBean(retmap.get("thpinfo"), Map.class);
            SignRes signRes = new SignRes();
            if (StrUtil.equals(thpinfo.get("trxstatus").toString(), "3999")) {
                String errMsg = retmap.get("errmsg");
                signRes.setRetcode(Constant.FAIL_CODE);
                signRes.setRetMsg(errMsg);
            } else if (StrUtil.equals(thpinfo.get("trxstatus").toString(), "1999")) {
                signRes.setRetMsg(ResponseResult.SMSVERIFICATIONCODESENT.getRetmsg());
                signRes.setRetcode(Constant.SUCCESS_CODE);
            }
            Sign sign = new Sign();
            sign.setAcctname(signReq.getAcctName());
            sign.setAcctno(signReq.getAcctNo());
            sign.setIdno(signReq.getIdNo());
            sign.setSignflag(0);
            sign.setAccttype(signReq.getAcctType());
            sign.setMobile(signReq.getPhone());
            sign.setPadcode(signReq.getArea());
            sign.setTraceDate(DateUtil.parse(signReq.getValiddate()).toSqlDate());
            ticketSignRepository.save(sign);
            return ResultBuilder.success(retmap);
        }
        return ResultBuilder.fail(ResponseResult.FAIL);
    }

    /**
     * 签约查询
     *
     * @param signQueryReq
     * @return
     */
    @Override
    public Result<SignQueryRes> signQuery(SignQueryReq signQueryReq) {
        Sign sign = ticketSignRepository.findByUserId(signQueryReq.getUid());
        if (sign == null) {
            return ResultBuilder.fail(ResponseResult.NOTSIGN);
        }
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.dkfpsq.agreeconfirm");
        map.put("userId", signQueryReq.getUid());
        map.put("sssf", signQueryReq.getProvinceCode());
        map.put("uuidxh", signQueryReq.getAddressUUid());
        map.put("accttype", signQueryReq.getAcctType());
        map.put("acctno", signQueryReq.getAcctNo());
        map.put("idno", signQueryReq.getIdNo());
        map.put("acctname", signQueryReq.getAcctName());
        map.put("mobile", signQueryReq.getPhone());
        map.put("cvv2", signQueryReq.getCvv2());
        map.put("validdate", signQueryReq.getValiddate());
        map.put("thpinfo", signQueryReq.getThpinfo());
        map.put("smscode", signQueryReq.getPhooneCode());
        Map<String, String> retmap = lixinConfig.postdata(map);
        SignQueryRes signQueryRes = new SignQueryRes();
        if (retmap.get("returncode").equals("00")) {
            ticketSignRepository.UpdateSignFlag(signQueryReq.getUid(), "1");
            signQueryRes.setRetcode(Constant.SUCCESS_CODE);
            signQueryRes.setRetMsg(retmap.get("returnMessage"));
            return ResultBuilder.success(signQueryRes);
        }
        return ResultBuilder.fail(retmap.get("returnMessage"));
    }

    /**
     * 登录
     *
     * @param loginReq
     * @return
     */
    @Override
    public Result<LoginRes> login(LoginReq loginReq) {
        User user = userRepository.findUserByUid(loginReq.getUid());
        if (user != null) {
            LoginRes loginRes = new LoginRes();
            loginRes.setRetcode(Constant.SUCCESS_CODE);
            loginRes.setAddress(user.getDistrict());
            loginRes.setIdNo(user.getIdno());
            loginRes.setUid(user.getUid());
            loginRes.setPhone(user.getPhone());
            return ResultBuilder.success(loginRes);
        }
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.login");
        map.put("userId", loginReq.getUid());
        map.put("sjhm", loginReq.getPhone());
        map.put("ZcFlag", loginReq.getZcFlag());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("returnCode"), "00")) {
            LoginRes loginRes = new LoginRes();
            loginRes.setRetMsg(ResponseResult.SUCCESSLOGIN.getRetmsg());
            loginRes.setUid(retmap.get("userId"));
            loginRes.setRetcode(Constant.SUCCESS_CODE);
            loginRes.setPhone(retmap.get("phone"));
            loginRes.setIdNo(retmap.get("sfzhm"));
            String address = retmap.get("shen") + retmap.get("shi") + retmap.get("qx");
            loginRes.setAddress(address);
            String AESKEY = retmap.get("aesKey");
            log.info("aesKey:{}", retmap.get("aesKey"));
            this.lixinConfig.setUrl(AESKEY);
            return ResultBuilder.success(loginRes);
        }
        return ResultBuilder.fail(retmap.get("returnMessage"));
    }

    /**
     * 获取区县
     *
     * @param provinceReq
     * @return
     */
    @Override
    public Result<String> Province(ProvinceReq provinceReq) {
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.getShenZc");
        map.put("userId", provinceReq.getUid());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("returnCode"), "00")) {
            return ResultBuilder.success(JSONUtil.toJsonStr(retmap));
        }
        return ResultBuilder.fail(ResponseResult.FAIL);
    }

    /**
     * 获取市
     *
     * @param cityReq
     * @return
     */
    @Override
    public Result<String> City(CityReq cityReq) {
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.getShiZc");
        map.put("userId", cityReq.getUid());
        map.put("xzqh_shen", cityReq.getProvince());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("returnCode"), "00")) {
            return ResultBuilder.success(JSONUtil.toJsonStr(retmap));
        }
        return ResultBuilder.fail(ResponseResult.FAIL);
    }

    /**
     * 获取区县
     *
     * @param districtReq
     * @return
     */
    @Override
    public Result<String> District(DistrictReq districtReq) {
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.getQxZc");
        map.put("userId", districtReq.getUid());
        map.put("xzqh_shi", districtReq.getCity());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("returnCode"), "00")) {
            return ResultBuilder.success(JSONUtil.toJsonStr(retmap));
        }
        return ResultBuilder.fail(ResponseResult.FAIL);
    }

    @Override
    public Result<SingleIssueRes> SingleIssue(SingleIssueReq signleIssueReq) {
        return null;
    }

    @Override
    public Result<SingleIssueQueryRes> SingleIssueQuery(SingleIssueQueryReq singleIssueQueryRes) {
        return null;
    }

    /**
     * 实名认证
     *
     * @param realNameAuthReq
     * @return
     */
    @Override
    @SneakyThrows
    public Result<RealNameAuthRes> rnameAuth(RealNameAuthReq realNameAuthReq) {
        Map<String, Object> map = new HashMap<>();
        map.put("zmz", BaseImg.Base64Img(realNameAuthReq.getIDCardFrontUrl().getInputStream()));
        map.put("fmz",  BaseImg.Base64Img(realNameAuthReq.getIDCardReverseUrl().getInputStream()));
        map.put("xcz",  BaseImg.Base64Img(realNameAuthReq.getFaceUrl().getInputStream()));
        map.put("ymlx", "sqypt.smrz.rz");
        map.put("userId", realNameAuthReq.getUid());
        map.put("sssf", realNameAuthReq.getSssf());
        map.put("sfzhm", realNameAuthReq.getIDCardNo());
        map.put("xm", realNameAuthReq.getName());
        map.put("sjhm", realNameAuthReq.getPhone());
        map.put("dz", realNameAuthReq.getIDCardAdr());
        map.put("yzqq", realNameAuthReq.getIDCardValidityStart());
        map.put("yxqz", realNameAuthReq.getIDCardValidityStop());
        map.put("mz", realNameAuthReq.getAction());
        map.put("qfjg", realNameAuthReq.getIssuingAuth());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (retmap.get("returnCode").equals("00")) {
            RealNameAuthRes realNameAuthRes = new RealNameAuthRes();
            realNameAuthRes.setRetcode(Constant.SUCCESS_CODE);
            realNameAuthRes.setRetMsg(Constant.ACCESS_SUCCESS);
            return ResultBuilder.success(realNameAuthRes);
        }
        return ResultBuilder.fail(retmap.get("returnMessage"));
    }

    @Override
    public Result<RealNameAuthQueryRes> rnameAuthQuery(RealNameAuthQueryReq realNameAuthQueryReq) {
        return null;
    }

    /**
     * 代开发票
     *
     * @param invoiceApplyReq
     * @return
     */
    @Override
    public Result<InvoiceApplyRes> InvoiceApply(InvoiceApplyReq invoiceApplyReq) {
        if (userRepository.findUserByUid(invoiceApplyReq.getUid()) == null) {
            return ResultBuilder.fail(ResponseResult.NOREGISTER);
        }
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.dkfpsq.save");
        map.put("sssf", invoiceApplyReq.getSssf());
        map.put("userId", invoiceApplyReq.getUid());
        map.put("xsf_mc", invoiceApplyReq.getXsfmc());
        map.put("gmfkhyh", invoiceApplyReq.getGmfkhyh());
        map.put("gmfdh", invoiceApplyReq.getGmfdh());
        map.put("bz", invoiceApplyReq.getBz());
        map.put("gmf_mc", invoiceApplyReq.getGmf_mc());
        map.put("xsfdz", invoiceApplyReq.getXsfdz());
        map.put("dksquuid", invoiceApplyReq.getDksquuid());
        map.put("gmf_nsrsbh", invoiceApplyReq.getGmf_nsrsbh());
        map.put("ybtdsse", invoiceApplyReq.getYbtdsse());
        map.put("zspm", invoiceApplyReq.getZspm());
        map.put("gmfdz", invoiceApplyReq.getGmfdz());
        map.put("bhsxse", invoiceApplyReq.getBhsxse());
        map.put("sezj", invoiceApplyReq.getSezj());
        map.put("sjhjxx", invoiceApplyReq.getSjhjxx());
        map.put("gmfyhzh", invoiceApplyReq.getGmfyhzh());
        map.put("xsfdh", invoiceApplyReq.getXsfdh());
        map.put("xsfyhzh", invoiceApplyReq.getXsfyhzh());
        map.put("ybtse", invoiceApplyReq.getYbtse());
        map.put("xsf_nsrsbh", invoiceApplyReq.getXsfnsrsbh());
        map.put("xsfkhyh", invoiceApplyReq.getXsfkhyh());
        map.put("dtwdDm", invoiceApplyReq.getDtwdDm());
        map.put("dk", invoiceApplyReq.getDk());
        Map<String, String> details = new HashMap<>();
        details.put("zsl", invoiceApplyReq.getZsl());
        details.put("xse", invoiceApplyReq.getXse());
        details.put("se", invoiceApplyReq.getSe());
        details.put("lx", invoiceApplyReq.getLx());
        details.put("dw", invoiceApplyReq.getDw());
        details.put("sl", StrUtil.toString(invoiceApplyReq.getSl()));
        details.put("dj", invoiceApplyReq.getDj());
        map.put("details", JSONUtil.toJsonStr(details));
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("returnCode"), "00")) {
            InvoiceApplyRes invoiceApplyRes = new InvoiceApplyRes();
            invoiceApplyRes.setDksquuidxh(retmap.get("dksquuidxh"));
            invoiceApplyRes.setRetcode(Constant.SUCCESS_CODE);
            invoiceApplyRes.setRetMsg(Constant.ACCESS_SUCCESS);
            return ResultBuilder.success(invoiceApplyRes);
        }
        return ResultBuilder.fail(retmap.get("returnMessage"));
    }

    /**
     * 获取商品信息
     *
     * @param goodsReq
     * @return
     */
    @Override
    public Result<GoodsRes> GoodsDetails(GoodsReq goodsReq) {
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.dkfpsq.getSpxx");
        map.put("userId", goodsReq.getUid());
        map.put("sssf", goodsReq.getProvincialCode());
        map.put("spxx", goodsReq.getGoodsName());
        map.put("pageSize", goodsReq.getPagesize());
        map.put("pageNumber", goodsReq.getPageNumber());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("returnCode"), "00")) {
            Map<String, String> spList = JSONUtil.toBean(JSONUtil.toJsonStr(retmap.get("content")), Map.class);
            GoodsRes goodsRes = new GoodsRes();
            goodsRes.setGoodsInfo(JSONUtil.toJsonStr(spList.get("spList")));
            goodsRes.setRetcode(Constant.SUCCESS_CODE);
            goodsRes.setRetMsg(ResponseResult.SUCCESS.getRetmsg());
            return ResultBuilder.success(goodsRes);
        }
        return ResultBuilder.fail(retmap.get("returnMessage"));
    }

    /**
     * 支付初始化
     *
     * @param payloadReq
     * @return
     */
    @Override
    public Result<PayRes> Payload(PayReq payloadReq) {
        if (userRepository.findUserByUid(payloadReq.getUid()) == null) {
            return ResultBuilder.fail(ResponseResult.FAIL);
        }
        Map<String, Object> map = new HashMap<>();
        map.put("ymlx", "sqypt.dkfpsq.doPay");
        map.put("sssf", payloadReq.getProvinceCode());
        map.put("userId", payloadReq.getUid());
        map.put("dksquuidxh", payloadReq.getDksquuidxh());
        map.put("dzuuidxh", payloadReq.getDzuuidxh());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("retcode"), "00")) {
            PayRes payloadRes = new PayRes();
            payloadRes.setTaxAmount(retmap.get("se"));
            payloadRes.setMailingAmount(retmap.get("yjje"));
            payloadRes.setDeductionAmount(retmap.get("kkje"));
            return ResultBuilder.success(payloadRes);
        }
        return ResultBuilder.fail(ResponseResult.FAIL);
    }

    /**
     * 支付（银行卡支付）
     *
     * @param payReq
     * @return
     */
    @Override
    public Result<PayRes> pay(PayReq payReq) {
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.dkfpsq.doPay");
        map.put("sssf", payReq.getProvinceCode());
        map.put("userId", payReq.getUid());
        map.put("dksquuidxh", payReq.getDaiKaiUUID());
        map.put("dzuuidxh", payReq.getAddressUUid());
        map.put("zfje", payReq.getPayMoney());
        map.put("zffs", payReq.getPayType());
        map.put("subject", payReq.getOrderContent());
        map.put("trxreserve", payReq.getTrxreserve());
        map.put("agreeid", payReq.getAgreeid());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("retcode"), "00")) {
            String status = retmap.get("trxstatus");
            PayRes payRes = new PayRes();
            if (StrUtil.equals(status, "1999") || StrUtil.equals(status, "3051")) {
                payRes.setAppid(retmap.get("appid"));
                payRes.setCusid(retmap.get("cusid"));
                payRes.setRetcode(Constant.SUCCESS_CODE);
                payRes.setRetMsg(Constant.ACCESS_SUCCESS);
                payRes.setThpinfo(retmap.get("thpinfo"));
            } else if (StrUtil.equals(status, "3999") || StrUtil.equals(status, "3004")) {
                payRes.setRetcode(Constant.FAIL_CODE);
                payRes.setRetMsg(retmap.get("errmsg"));
            }
            Trace trace = new Trace();
            trace.setTradeStatus("0");
            trace.setPayType("yhk");
            trace.setUpOrderId(retmap.get("orderid"));
            trace.setDeductionMoney(payReq.getPayMoney());
            traceRepository.save(trace);
            return ResultBuilder.success(payRes);
        }
        return ResultBuilder.fail(retmap.get("errmsg"));
    }


    /**
     * 支付确认
     */
    @Override
    public Result<PayConfirmReq> payConfirm(PayConfirmReq payConfirmReq) {
        Trace trace = traceRepository.findTracesByUpOrderId(payConfirmReq.getOrderid());
        if (trace != null) {
            String status = trace.getTradeStatus();
            PayConfirmRes payConfirmRes = new PayConfirmRes();
            if (StrUtil.equals(status, "1")) {
                payConfirmRes.setRetMsg(Constant.ACCESS_SUCCESS);
                payConfirmRes.setRetcode(Constant.SUCCESS_CODE);
                payConfirmRes.setAcctNoNumber(trace.getUpOrderId());
            } else if (StrUtil.equals(status, "2")) {
                payConfirmRes.setRetMsg(Constant.ACCESS_FAIL);
                payConfirmRes.setRetcode(Constant.FAIL_CODE);
            }
        }
        Map<String, Object> map = new HashMap<>();
        map.put("ywlx", "sqypt.dkfpsq.pay");
        map.put("userId", payConfirmReq.getUid());
        map.put("sssf", payConfirmReq.getProvinceCode());
        map.put("smscode", payConfirmReq.getSmsCode());
        map.put("orderid", payConfirmReq.getOrderid());
        map.put("agreeid", payConfirmReq.getAgreeId());
        map.put("thpinfo", payConfirmReq.getThpinfo());
        Map<String, String> retmap = lixinConfig.postdata(map);
        if (StrUtil.equals(retmap.get("retcode"), "00")) {
            String status = retmap.get("trxstatus");
            PayConfirmRes payConfirmReS = new PayConfirmRes();
            if (StrUtil.equals(status, "0000")) {
                payConfirmReS.setRetcode(Constant.SUCCESS_CODE);
                payConfirmReS.setRetMsg(Constant.ACCESS_SUCCESS);
                payConfirmReS.setTrxid(retmap.get("trxid"));
                payConfirmReS.setAcctNoNumber(retmap.get("orderid"));
            } else if (StrUtil.equals(status, "1999")) {
                payConfirmReS.setRetcode(Constant.PROCESSE_CODE);
                payConfirmReS.setRetMsg(retmap.get("errmsg"));
            } else if (StrUtil.equals(status, "2008") || StrUtil.equals(status, "2000")) {
                payConfirmReS.setRetcode(Constant.PROCESSE_CODE);
                payConfirmReS.setRetMsg(Constant.PROCESSE_DESC);
            }
            return ResultBuilder.fail(retmap.get("errmsg"));
        }
        return ResultBuilder.fail(retmap.get("errmsg"));
    }

    /**
     * 充值
     * @param rechargeReq
     * @return
     */
    @Override
    public Result<RechargeRes> Recharge(RechargeReq rechargeReq) {

        return null;
    }

    /**
     * 充值查询
     * @param rechargeQueryReq
     * @return
     */
    @Override
    public Result<RechargeQueryRes> RechargeQuery(RechargeQueryReq rechargeQueryReq) {
        return null;
    }

    /**
     * 账户查询
     * @param subAcctQueryReq
     * @return
     */
    @Override
    public Result<SubAcctQueryRes> SubAcctQuery(SubAcctQueryReq subAcctQueryReq) {
        return null;
    }

}
